package com.hyperboost.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.hyperboost.constant.MessageConstant;
import com.hyperboost.dto.OpportunityCommentDTO;
import com.hyperboost.dto.OpportunityCommentPageQueryDTO;
import com.hyperboost.dto.OpportunityCommentReplyQueryDTO;
import com.hyperboost.entity.OpportunityComment;
import com.hyperboost.exception.NoPermissionToDelete;
import com.hyperboost.mapper.OpportunityCommentMapper;
import com.hyperboost.mapper.OpportunityMapper;
import com.hyperboost.result.PageResult;
import com.hyperboost.service.OpportunityCommentService;
import com.hyperboost.utils.ThreadLocalUtil;
import com.hyperboost.vo.OpportunityCommentReplyVO;
import com.hyperboost.vo.OpportunityCommentVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;
import java.util.Map;

@Service
public class OpportunityCommentServiceImpl implements OpportunityCommentService {

    @Autowired
    private OpportunityCommentMapper commentMapper;

    @Autowired
    private OpportunityMapper opportunityMapper;

    /**
     * 新增评论
     *
     * @param commentDTO
     */
    @Override
    public void addComment(OpportunityCommentDTO commentDTO) {

        // 对象属性拷贝，将commentDTO中的属性值拷贝到comment对象中
        OpportunityComment comment = new OpportunityComment();
        BeanUtils.copyProperties(commentDTO, comment);

        // 判断是否为顶级评论
        if (commentDTO.getParentId() == null){
            // 新增评论为顶级评论
            comment.setParentId(null);
            comment.setTopId(null);
        }else {
            // 新增评论为子评论
            // 判断父评论是否为顶级评论
            OpportunityComment parentComment = commentMapper.getCommentByCommentId(commentDTO.getParentId());
            if (parentComment.getTopId() != null) {
                // 父评论也是子评论，记录父评论的topId作为当前评论的topId
                comment.setTopId(parentComment.getTopId());
            } else {
                // 父评论是顶级评论，记录父评论的commentId作为当前评论的topId
                comment.setTopId(parentComment.getCommentId());
            }

        }
        // 获取当前登录用户的ID和用户名，作为新增评论数据实体类的属性值
        Map<String, Object> map =  ThreadLocalUtil.get();
        Long userId = ((Number) map.get("userId")).longValue();
        String username = (String) map.get("username");

        // 设置实体类对象的属性
        comment.setUserId(userId);
        comment.setCreateBy(username);

        // 新增评论数据
        commentMapper.insert(comment);

        // 评论成功，同步更新机会的评论数量
        opportunityMapper.increaseCommentCount(comment.getOpportunityId());
    }

    /**
     * 删除评论
     *
     * @param commentId
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void deleteComment(Long commentId) {

        // 获取当前登录用户的ID，作为判断是否有权限删除评论的条件
        Map<String, Object> map =  ThreadLocalUtil.get();
        Long userId = ((Number) map.get("userId")).longValue();

        // 根据评论ID获取评论信息
        OpportunityComment comment = commentMapper.getCommentByCommentId(commentId);

        // 判断当前评论是否属于当前登录用户
        if (! comment.getUserId().equals(userId)){
            throw new NoPermissionToDelete(MessageConstant.NO_PERMISSION_TO_DELETE);
        }

        // 记录删除的评论数量，作为同步更新机会评论数量的参数
        int deleteCommentCount = 1;

        // 判断当前是否为顶级评论
        if (comment.getTopId() == null){
            // 顶级评论，调用commentMapper的deleteCommentByTopId方法，删除所有评论
            // 记录所有评论数量，用于同步更新机会的评论数量
            int totalCommentCount = commentMapper.childCountByTopId(commentId);
            deleteCommentCount += totalCommentCount;
            commentMapper.deleteCommentByTopId(commentId);
        }else {
            // 记录子评论数量，用于同步更新机会的评论数量
            int childCommentCount = commentMapper.childCountByParentId(commentId);
            deleteCommentCount += childCommentCount;
            commentMapper.deleteCommentByParentId(commentId);
        }
        commentMapper.deleteCommentByCommentId(commentId);
        opportunityMapper.decreaseCommentCount(comment.getOpportunityId(),deleteCommentCount);
    }

    /**
     * 分页查询顶级评论
     *
     * @param commentPageQueryDTO
     * @return
     */
    @Override
    public PageResult<OpportunityCommentVO> pageQuery(OpportunityCommentPageQueryDTO commentPageQueryDTO) {

        // 调用PageHelper的startPage方法，设置分页的页码PageNum和每页显示的记录数PageSize
        PageHelper.startPage(commentPageQueryDTO.getPageNum(), commentPageQueryDTO.getPageSize());

        // 调用commentMapper的pageQuery方法，分页查询机会评论数据，以OpportunityCommentVO类型的列表形式返回
        List<OpportunityCommentVO> commentVOList = commentMapper.pageQuery(commentPageQueryDTO);

        // 将分页查询结果列表转换为Page类型的对象，以便获取分页相关的信息
        Page<OpportunityCommentVO> page = (Page<OpportunityCommentVO>) commentVOList;

        // 返回分页查询的结果
        return new PageResult<>(page.getTotal(), page.getResult());
    }

    /**
     * 查询回复评论列表
     *
     * @param commentReplyQueryDTO
     * @return
     */
    @Override
    public List<OpportunityCommentReplyVO> listReply(OpportunityCommentReplyQueryDTO commentReplyQueryDTO) {

        // topID作为查询条件，查询回复评论列表
        Long topId = commentReplyQueryDTO.getTopId();
        // parentID作为查询条件，查询回复关系
        Long parentId = commentReplyQueryDTO.getParentId();

        // 调用commentMapper的listReply方法，查询回复评论列表，以OpportunityCommentReplyVO类型的列表形式返回
        List<OpportunityCommentReplyVO> commentReplyVOList = commentMapper.listReply(topId, parentId);

        // 返回回复评论列表
        return commentReplyVOList;
    }
}



